//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.icson.deal.idl.ShoppingCartMsgqPo.java


#ifndef ICSON_DEAL_SHOPPINGCART_BO_CSHOPPINGCARTMSGQOBJECT_BY_AUTOGEN_V5_H
#define ICSON_DEAL_SHOPPINGCART_BO_CSHOPPINGCARTMSGQOBJECT_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <vector>
#include <map>
#include "icson/deal/shoppingcart/bo/shoppingcartproductmsgq_deal.h"
#include "icson/deal/shoppingcart/bo/adderrorstruct_deal.h"
#include <string>
#include <sstream>
#include <iostream>


namespace icson
{
namespace deal
{
namespace shoppingcart
{
namespace bo
{


class CShoppingcartMsgqObject : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 * 协议版本号
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * 版本 >= 0
		 */
		uint8_t cVersion_u;

		/**
		 * 登录情况下的用户易迅ID, 若没登录情况时该值为0
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwUserId;

		/**
		 * 版本 >= 0
		 */
		uint8_t cUserId_u;

		/**
		 * 未登录情况下cookie中的yx_uid值, 若无该值则为0
		 *
		 * 版本 >= 0
		 */
		uint64_t ddwCookieUid;

		/**
		 * 版本 >= 0
		 */
		uint8_t cCookieUid_u;

		/**
		 * ip地址
		 *
		 * 版本 >= 0
		 */
		std::string strUserIp;

		/**
		 * 版本 >= 0
		 */
		uint8_t cUserIp_u;

		/**
		 * 业务请求方来源, (暂未使用)
		 *
		 * 版本 >= 0
		 */
		uint32_t dwFrom;

		/**
		 * 版本 >= 0
		 */
		uint8_t cFrom_u;

		/**
		 * 添加成功1, 失败0:
		 *
		 * 版本 >= 0
		 */
		uint8_t cIsAddSuccess;

		/**
		 * 版本 >= 0
		 */
		uint8_t cIsAddSuccess_u;

		/**
		 * 商品列表
		 *
		 * 版本 >= 0
		 */
		std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq>  vecProductList;

		/**
		 * 版本 >= 0
		 */
		uint8_t cProductList_u;

		/**
		 * 添加失败时的错误, KEY: 商品ID, 错误码.
		 *
		 * 版本 >= 0
		 */
		std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct>  mapFailedErrors;

		/**
		 * 版本 >= 0
		 */
		uint8_t cFailedErrors_u;




	public:
		CShoppingcartMsgqObject():
		dwVersion(0),
		cVersion_u(0),
		ddwUserId(0),
		cUserId_u(0),
		ddwCookieUid(0),
		cCookieUid_u(0),
		cUserIp_u(0),
		dwFrom(0),
		cFrom_u(0),
		cIsAddSuccess(0),
		cIsAddSuccess_u(0),
		cProductList_u(0),
		cFailedErrors_u(0) {}
				CShoppingcartMsgqObject& operator = (const CShoppingcartMsgqObject& obj){

			this->dwVersion = obj.dwVersion;
			this->cVersion_u = obj.cVersion_u;
			this->ddwUserId = obj.ddwUserId;
			this->cUserId_u = obj.cUserId_u;
			this->ddwCookieUid = obj.ddwCookieUid;
			this->cCookieUid_u = obj.cCookieUid_u;
			this->strUserIp = obj.strUserIp;
			this->cUserIp_u = obj.cUserIp_u;
			this->dwFrom = obj.dwFrom;
			this->cFrom_u = obj.cFrom_u;
			this->cIsAddSuccess = obj.cIsAddSuccess;
			this->cIsAddSuccess_u = obj.cIsAddSuccess_u;
			this->vecProductList = obj.vecProductList;
			this->cProductList_u = obj.cProductList_u;
			this->mapFailedErrors = obj.mapFailedErrors;
			this->cFailedErrors_u = obj.cFailedErrors_u;
			return *this;
		}

	public:


		/**
		 * 是否设置协议版本号了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag协议版本号了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置协议版本号
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取协议版本号
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cVersion_u
		 *  
		 * 
		 */
		 void  SetVersion_u( const uint8_t& sVal){
				cVersion_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cVersion_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetVersion_u() const {
				return cVersion_u;
		}


		/**
		 * 是否设置登录情况下的用户易迅ID, 若没登录情况时该值为0了
		 * 
		 * @param uint64_t:ddwUserId
		 *  
		 * 
		 */
		 bool  IsUserIdSet() const{
				 return  cUserId_u != 0;
		}


		/**
		 * 获取uflag登录情况下的用户易迅ID, 若没登录情况时该值为0了
		 * 
		 * @param uint64_t:ddwUserId
		 *  
		 * 
		 */
		 const uint8_t   GetUserIdUFlag() const{
				 return  cUserId_u;
		}


		/**
		 * 设置登录情况下的用户易迅ID, 若没登录情况时该值为0
		 * 
		 * @param uint64_t:ddwUserId
		 *  
		 * 
		 */
		 void  SetUserId( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwUserId = sVal;
				cUserId_u = cUFlag;
		}


		/**
		 * 获取登录情况下的用户易迅ID, 若没登录情况时该值为0
		 * 
		 * @return ddwUserId value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetUserId() const {
				return ddwUserId;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cUserId_u
		 *  
		 * 
		 */
		 void  SetUserId_u( const uint8_t& sVal){
				cUserId_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cUserId_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetUserId_u() const {
				return cUserId_u;
		}


		/**
		 * 是否设置未登录情况下cookie中的yx_uid值, 若无该值则为0了
		 * 
		 * @param uint64_t:ddwCookieUid
		 *  
		 * 
		 */
		 bool  IsCookieUidSet() const{
				 return  cCookieUid_u != 0;
		}


		/**
		 * 获取uflag未登录情况下cookie中的yx_uid值, 若无该值则为0了
		 * 
		 * @param uint64_t:ddwCookieUid
		 *  
		 * 
		 */
		 const uint8_t   GetCookieUidUFlag() const{
				 return  cCookieUid_u;
		}


		/**
		 * 设置未登录情况下cookie中的yx_uid值, 若无该值则为0
		 * 
		 * @param uint64_t:ddwCookieUid
		 *  
		 * 
		 */
		 void  SetCookieUid( const uint64_t& sVal, uint8_t cUFlag=1){
				ddwCookieUid = sVal;
				cCookieUid_u = cUFlag;
		}


		/**
		 * 获取未登录情况下cookie中的yx_uid值, 若无该值则为0
		 * 
		 * @return ddwCookieUid value 类型为:uint64_t
		 * 
		 */
		 const uint64_t&  GetCookieUid() const {
				return ddwCookieUid;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cCookieUid_u
		 *  
		 * 
		 */
		 void  SetCookieUid_u( const uint8_t& sVal){
				cCookieUid_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cCookieUid_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetCookieUid_u() const {
				return cCookieUid_u;
		}


		/**
		 * 是否设置ip地址了
		 * 
		 * @param std::string:strUserIp
		 *  
		 * 
		 */
		 bool  IsUserIpSet() const{
				 return  cUserIp_u != 0;
		}


		/**
		 * 获取uflagip地址了
		 * 
		 * @param std::string:strUserIp
		 *  
		 * 
		 */
		 const uint8_t   GetUserIpUFlag() const{
				 return  cUserIp_u;
		}


		/**
		 * 设置ip地址
		 * 
		 * @param std::string:strUserIp
		 *  
		 * 
		 */
		 void  SetUserIp( const std::string& sVal, uint8_t cUFlag=1){
				strUserIp = sVal;
				cUserIp_u = cUFlag;
		}


		/**
		 * 获取ip地址
		 * 
		 * @return strUserIp value 类型为:std::string
		 * 
		 */
		 const std::string&  GetUserIp() const {
				return strUserIp;
		}


		/**
		 * 获取ip地址
		 * 
		 * @return strUserIp value 类型为:std::string
		 * 
		 */
		 std::string&  GetUserIp() {
				return strUserIp;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cUserIp_u
		 *  
		 * 
		 */
		 void  SetUserIp_u( const uint8_t& sVal){
				cUserIp_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cUserIp_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetUserIp_u() const {
				return cUserIp_u;
		}


		/**
		 * 是否设置业务请求方来源, (暂未使用)了
		 * 
		 * @param uint32_t:dwFrom
		 *  
		 * 
		 */
		 bool  IsFromSet() const{
				 return  cFrom_u != 0;
		}


		/**
		 * 获取uflag业务请求方来源, (暂未使用)了
		 * 
		 * @param uint32_t:dwFrom
		 *  
		 * 
		 */
		 const uint8_t   GetFromUFlag() const{
				 return  cFrom_u;
		}


		/**
		 * 设置业务请求方来源, (暂未使用)
		 * 
		 * @param uint32_t:dwFrom
		 *  
		 * 
		 */
		 void  SetFrom( const uint32_t& sVal, uint8_t cUFlag=1){
				dwFrom = sVal;
				cFrom_u = cUFlag;
		}


		/**
		 * 获取业务请求方来源, (暂未使用)
		 * 
		 * @return dwFrom value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetFrom() const {
				return dwFrom;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cFrom_u
		 *  
		 * 
		 */
		 void  SetFrom_u( const uint8_t& sVal){
				cFrom_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cFrom_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetFrom_u() const {
				return cFrom_u;
		}


		/**
		 * 是否设置添加成功1, 失败0:了
		 * 
		 * @param uint8_t:cIsAddSuccess
		 *  
		 * 
		 */
		 bool  IsIsAddSuccessSet() const{
				 return  cIsAddSuccess_u != 0;
		}


		/**
		 * 获取uflag添加成功1, 失败0:了
		 * 
		 * @param uint8_t:cIsAddSuccess
		 *  
		 * 
		 */
		 const uint8_t   GetIsAddSuccessUFlag() const{
				 return  cIsAddSuccess_u;
		}


		/**
		 * 设置添加成功1, 失败0:
		 * 
		 * @param uint8_t:cIsAddSuccess
		 *  
		 * 
		 */
		 void  SetIsAddSuccess( const uint8_t& sVal, uint8_t cUFlag=1){
				cIsAddSuccess = sVal;
				cIsAddSuccess_u = cUFlag;
		}


		/**
		 * 获取添加成功1, 失败0:
		 * 
		 * @return cIsAddSuccess value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetIsAddSuccess() const {
				return cIsAddSuccess;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cIsAddSuccess_u
		 *  
		 * 
		 */
		 void  SetIsAddSuccess_u( const uint8_t& sVal){
				cIsAddSuccess_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cIsAddSuccess_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetIsAddSuccess_u() const {
				return cIsAddSuccess_u;
		}


		/**
		 * 是否设置商品列表了
		 * 
		 * @param std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> :vecProductList
		 *  
		 * 
		 */
		 bool  IsProductListSet() const{
				 return  cProductList_u != 0;
		}


		/**
		 * 获取uflag商品列表了
		 * 
		 * @param std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> :vecProductList
		 *  
		 * 
		 */
		 const uint8_t   GetProductListUFlag() const{
				 return  cProductList_u;
		}


		/**
		 * 设置商品列表
		 * 
		 * @param std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> :vecProductList
		 *  
		 * 
		 */
		 void  SetProductList( const std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> & sVal, uint8_t cUFlag=1){
				vecProductList = sVal;
				cProductList_u = cUFlag;
		}


		/**
		 * 获取商品列表
		 * 
		 * @return vecProductList value 类型为:std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> 
		 * 
		 */
		 const std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> &  GetProductList() const {
				return vecProductList;
		}


		/**
		 * 获取商品列表
		 * 
		 * @return vecProductList value 类型为:std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> 
		 * 
		 */
		 std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq> &  GetProductList() {
				return vecProductList;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cProductList_u
		 *  
		 * 
		 */
		 void  SetProductList_u( const uint8_t& sVal){
				cProductList_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cProductList_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetProductList_u() const {
				return cProductList_u;
		}


		/**
		 * 是否设置添加失败时的错误, KEY: 商品ID, 错误码.了
		 * 
		 * @param std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> :mapFailedErrors
		 *  
		 * 
		 */
		 bool  IsFailedErrorsSet() const{
				 return  cFailedErrors_u != 0;
		}


		/**
		 * 获取uflag添加失败时的错误, KEY: 商品ID, 错误码.了
		 * 
		 * @param std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> :mapFailedErrors
		 *  
		 * 
		 */
		 const uint8_t   GetFailedErrorsUFlag() const{
				 return  cFailedErrors_u;
		}


		/**
		 * 设置添加失败时的错误, KEY: 商品ID, 错误码.
		 * 
		 * @param std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> :mapFailedErrors
		 *  
		 * 
		 */
		 void  SetFailedErrors( const std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> & sVal, uint8_t cUFlag=1){
				mapFailedErrors = sVal;
				cFailedErrors_u = cUFlag;
		}


		/**
		 * 获取添加失败时的错误, KEY: 商品ID, 错误码.
		 * 
		 * @return mapFailedErrors value 类型为:std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> 
		 * 
		 */
		 const std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> &  GetFailedErrors() const {
				return mapFailedErrors;
		}


		/**
		 * 获取添加失败时的错误, KEY: 商品ID, 错误码.
		 * 
		 * @return mapFailedErrors value 类型为:std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> 
		 * 
		 */
		 std::map<uint64_t,icson::deal::shoppingcart::bo::CAddErrorStruct> &  GetFailedErrors() {
				return mapFailedErrors;
		}


		/**
		 * 设置
		 * 
		 * 此字段的版本 >= 1
		 * @param uint8_t:cFailedErrors_u
		 *  
		 * 
		 */
		 void  SetFailedErrors_u( const uint8_t& sVal){
				cFailedErrors_u = sVal;
		}


		/**
		 * 获取
		 * 
		 * @return cFailedErrors_u value 类型为:uint8_t
		 * 
		 */
		 const uint8_t&  GetFailedErrors_u() const {
				return cFailedErrors_u;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化协议版本号 类型为uint32_t
			bsTmp & cVersion_u; // 序列化 类型为uint8_t
			bsTmp & ddwUserId; // 序列化登录情况下的用户易迅ID, 若没登录情况时该值为0 类型为uint64_t
			bsTmp & cUserId_u; // 序列化 类型为uint8_t
			bsTmp & ddwCookieUid; // 序列化未登录情况下cookie中的yx_uid值, 若无该值则为0 类型为uint64_t
			bsTmp & cCookieUid_u; // 序列化 类型为uint8_t
			bsTmp & strUserIp; // 序列化ip地址 类型为String
			bsTmp & cUserIp_u; // 序列化 类型为uint8_t
			bsTmp & dwFrom; // 序列化业务请求方来源, (暂未使用) 类型为uint32_t
			bsTmp & cFrom_u; // 序列化 类型为uint8_t
			bsTmp & cIsAddSuccess; // 序列化添加成功1, 失败0: 类型为uint8_t
			bsTmp & cIsAddSuccess_u; // 序列化 类型为uint8_t
			bsTmp & vecProductList; // 序列化商品列表 类型为Vector
			bsTmp & cProductList_u; // 序列化 类型为uint8_t
			bsTmp & mapFailedErrors; // 序列化添加失败时的错误, KEY: 商品ID, 错误码. 类型为Map
			bsTmp & cFailedErrors_u; // 序列化 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyShoppingcartMsgqObject(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:Version";
				return false;
			}

			if(!IsUserIdSet()){
				m_sLastErrMsg = "Miss Param:userId";
				return false;
			}

			if(!IsCookieUidSet()){
				m_sLastErrMsg = "Miss Param:cookieUid";
				return false;
			}

			if(!IsUserIpSet()){
				m_sLastErrMsg = "Miss Param:userIp";
				return false;
			}

			if(!IsFromSet()){
				m_sLastErrMsg = "Miss Param:from";
				return false;
			}

			if(!IsIsAddSuccessSet()){
				m_sLastErrMsg = "Miss Param:isAddSuccess";
				return false;
			}

			if(!IsProductListSet()){
				m_sLastErrMsg = "Miss Param:productList";
				return false;
			}

			if(!IsFailedErrorsSet()){
				m_sLastErrMsg = "Miss Param:failedErrors";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[ddwUserId:"<<ddwUserId<<"] ";
			oss<<"[cUserId_u:"<<(int)cUserId_u<<"] ";
			oss<<"[ddwCookieUid:"<<ddwCookieUid<<"] ";
			oss<<"[cCookieUid_u:"<<(int)cCookieUid_u<<"] ";
			oss<<"[strUserIp:"<<strUserIp<<"] ";
			oss<<"[cUserIp_u:"<<(int)cUserIp_u<<"] ";
			oss<<"[dwFrom:"<<dwFrom<<"] ";
			oss<<"[cFrom_u:"<<(int)cFrom_u<<"] ";
			oss<<"[cIsAddSuccess:"<<(int)cIsAddSuccess<<"] ";
			oss<<"[cIsAddSuccess_u:"<<(int)cIsAddSuccess_u<<"] ";

			std::vector<icson::deal::shoppingcart::bo::CShoppingcartProductMsgq>::const_iterator itervecProductList=vecProductList.begin();
			for(int i=0; itervecProductList!=vecProductList.end();itervecProductList++,i++){
				oss<<"[vecProductList:";
				itervecProductList->DumpData(oss);
				oss<<"] ";
			}
			oss<<"[cProductList_u:"<<(int)cProductList_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cFailedErrors_u:"<<(int)cFailedErrors_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"cVersion_u:"<<cVersion_u;
			oss<<"ddwUserId:"<<ddwUserId;
			oss<<"cUserId_u:"<<cUserId_u;
			oss<<"ddwCookieUid:"<<ddwCookieUid;
			oss<<"cCookieUid_u:"<<cCookieUid_u;
			oss<<"strUserIp:"<<strUserIp;
			oss<<"cUserIp_u:"<<cUserIp_u;
			oss<<"dwFrom:"<<dwFrom;
			oss<<"cFrom_u:"<<cFrom_u;
			oss<<"cIsAddSuccess:"<<cIsAddSuccess;
			oss<<"cIsAddSuccess_u:"<<cIsAddSuccess_u;
			oss<<"vecProductList:"<<vecProductList;
			oss<<"cProductList_u:"<<cProductList_u;
			oss<<"mapFailedErrors:"<<mapFailedErrors;
			oss<<"cFailedErrors_u:"<<cFailedErrors_u;
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "ddwUserId", ddwUserId, ident);
			g_pprint(os, "cUserId_u", cUserId_u, ident);
			g_pprint(os, "ddwCookieUid", ddwCookieUid, ident);
			g_pprint(os, "cCookieUid_u", cCookieUid_u, ident);
			g_pprint(os, "strUserIp", strUserIp, ident);
			g_pprint(os, "cUserIp_u", cUserIp_u, ident);
			g_pprint(os, "dwFrom", dwFrom, ident);
			g_pprint(os, "cFrom_u", cFrom_u, ident);
			g_pprint(os, "cIsAddSuccess", cIsAddSuccess, ident);
			g_pprint(os, "cIsAddSuccess_u", cIsAddSuccess_u, ident);
			g_pprint(os, "vecProductList", vecProductList, ident);
			g_pprint(os, "cProductList_u", cProductList_u, ident);
			g_pprint(os, "mapFailedErrors", mapFailedErrors, ident);
			g_pprint(os, "cFailedErrors_u", cFailedErrors_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}
}

#endif /* ICSON_DEAL_SHOPPINGCART_BO_CSHOPPINGCARTMSGQOBJECT_BY_AUTOGEN_V5_H */
